//#define _CRT_SECURE_NO_WARNINGS
//#include"Common.h"
//#include "ConcurrentAlloc.h"
//void BenchmarkMalloc(size_t ntimes, size_t nworks, size_t rounds)
//{
//	std::vector<std::thread>vthread(nworks);
//	std::atomic<size_t> malloc_costtime = 0;
//	std::atomic<size_t> free_costtime = 0;
//	for (size_t k = 0; k < nworks; ++k)
//	{
//		vthread[k] = std::thread([ &, k]()
//		{
//			std::vector<void*> v;
//			v.reserve(ntimes);
//			for (size_t j = 0; j < rounds; ++j)
//			{
//				size_t begin1 = clock();
//				for (size_t i = 0; i < ntimes; i++)
//				{
//				v.push_back(malloc(16));
//				//v.push_back(malloc((16 + i) % 8192 + 1));
//				}
//				size_t end1 = clock();
//				size_t begin2 = clock();
//				for (size_t i = 0; i < ntimes; i++)
//				{
//					free(v[i]);
//				}
//				size_t end2 = clock();
//
//				v.clear();
//				malloc_costtime += (end1 - begin1);
//				free_costtime += (end2 - begin2);
//			}
//		});
//	}
//	for (auto& t : vthread)
//	{
//		t.join();
//	}
//	printf("%u个线程并发执⾏%u轮次，每轮次malloc %u次: 花费：%u ms\n",
//		nworks, rounds, ntimes, malloc_costtime);
//	printf("%u个线程并发执⾏%u轮次，每轮次free %u次: 花费：%u ms\n",
//		nworks, rounds, ntimes, free_costtime);
//	printf("%u个线程并发malloc&free %u次，总计花费：%u ms\n",
//		nworks, nworks * rounds * ntimes, malloc_costtime + free_costtime);
//}
//// 单轮次申请释放次数 线程数 轮次
//void BenchmarkConcurrentMalloc(size_t ntimes, size_t nworks, size_t rounds)
//{
//	std::vector<std::thread> vthread(nworks);
//	std::atomic<size_t> malloc_costtime = 0;
//	std::atomic<size_t> free_costtime = 0;
//	for (size_t k = 0; k < nworks; ++k)
//	{
//		vthread[k] = std::thread([&]() 
//		{
//			std::vector<void*> v;
//			v.reserve(ntimes);
//			for (size_t j = 0; j < rounds; ++j)
//			{
//				size_t begin1 = clock();
//				for (size_t i = 0; i < ntimes; i++)
//				{
//					v.push_back(ConcurrentAlloc(16));
//					//v.push_back(ConcurrentAlloc((16 + i) % 8192 + 1));
//				}
//				size_t end1 = clock();
//				size_t begin2 = clock();
//				for (size_t i = 0; i < ntimes; i++)
//				{
//					ConcurrentFree(v[i]);
//				}
//				size_t end2 = clock();
//				v.clear();
//				malloc_costtime += (end1 - begin1);
//				free_costtime += (end2 - begin2);
//			}
//		});
//	}
//	for (auto& t : vthread)
//	{
//		t.join();
//	}
//	printf("%u个线程并发执⾏%u轮次，每轮次concurrent alloc %u次: 花费：%u ms\n",
//		nworks, rounds, ntimes, malloc_costtime);
//	printf("%u个线程并发执⾏%u轮次，每轮次concurrent dealloc %u次: 花费：%u ms\n",
//		nworks, rounds, ntimes, free_costtime);
//	printf("%u个线程并发concurrent alloc&dealloc %u次，总计花费：%u ms\n",
//		nworks, nworks * rounds * ntimes, malloc_costtime + free_costtime);
//}
//int main()
//{
//	size_t n = 10000;
//	cout << "==========================================================" <<
//		endl;
//	BenchmarkConcurrentMalloc(n, 4, 10);
//	cout << endl << endl;
//	BenchmarkMalloc(n, 4, 10);
//	cout << "==========================================================" <<
//		endl;
//	return 0;
//}
#define _CRT_SECURE_NO_WARNINGS
#include"Common.h"
#include "ConcurrentAlloc.h"
#include <iostream>
#include <thread>
#include <vector>
#include <atomic>
#include <cstdio>
#include <ctime>

void BenchmarkMalloc(size_t ntimes, size_t nworks, size_t rounds)
{
    std::vector<std::thread>vthread(nworks);
    std::atomic<size_t> malloc_costtime = 0;
    std::atomic<size_t> free_costtime = 0;
    for (size_t k = 0; k < nworks; ++k)
    {
        vthread[k] = std::thread([&, k]()
            {
                std::vector<void*> v;
                v.reserve(ntimes);
                for (size_t j = 0; j < rounds; ++j)
                {
                    size_t begin1 = clock();
                    for (size_t i = 0; i < ntimes; i++)
                    {
                        v.push_back(malloc(16));
                        //v.push_back(malloc((16 + i) % 8192 + 1));
                    }
                    size_t end1 = clock();
                    size_t begin2 = clock();
                    for (size_t i = 0; i < ntimes; i++)
                    {
                        free(v[i]);
                    }
                    size_t end2 = clock();

                    v.clear();
                    malloc_costtime += (end1 - begin1);
                    free_costtime += (end2 - begin2);
                }
            });
    }
    for (auto& t : vthread)
    {
        t.join();
    }
    // 加载atomic的值到普通变量后再输出
    size_t malloc_time = malloc_costtime.load();
    size_t free_time = free_costtime.load();
    size_t total_time = malloc_time + free_time;
    printf("%u个线程并发执⾏%u轮次，每轮次malloc %u次: 花费：%u ms\n",
        nworks, rounds, ntimes, (unsigned int)malloc_time);
    printf("%u个线程并发执⾏%u轮次，每轮次free %u次: 花费：%u ms\n",
        nworks, rounds, ntimes, (unsigned int)free_time);
    printf("%u个线程并发malloc&free %u次，总计花费：%u ms\n",
        nworks, nworks * rounds * ntimes, (unsigned int)total_time);
}

void BenchmarkConcurrentMalloc(size_t ntimes, size_t nworks, size_t rounds)
{
    std::vector<std::thread> vthread(nworks);
    std::atomic<size_t> malloc_costtime = 0;
    std::atomic<size_t> free_costtime = 0;
    for (size_t k = 0; k < nworks; ++k)
    {
        vthread[k] = std::thread([&]()
            {
                std::vector<void*> v;
                v.reserve(ntimes);
                for (size_t j = 0; j < rounds; ++j)
                {
                    size_t begin1 = clock();
                    for (size_t i = 0; i < ntimes; i++)
                    {
                        v.push_back(ConcurrentAlloc(16));
                        //v.push_back(ConcurrentAlloc((16 + i) % 8192 + 1));
                    }
                    size_t end1 = clock();
                    size_t begin2 = clock();
                    for (size_t i = 0; i < ntimes; i++)
                    {
                        ConcurrentFree(v[i]);
                    }
                    size_t end2 = clock();
                    v.clear();
                    malloc_costtime += (end1 - begin1);
                    free_costtime += (end2 - begin2);
                }
            });
    }
    for (auto& t : vthread)
    {
        t.join();
    }
    // 加载atomic的值到普通变量后再输出
    size_t malloc_time = malloc_costtime.load();
    size_t free_time = free_costtime.load();
    size_t total_time = malloc_time + free_time;
    printf("%u个线程并发执⾏%u轮次，每轮次concurrent alloc %u次: 花费：%u ms\n",
        nworks, rounds, ntimes, (unsigned int)malloc_time);
    printf("%u个线程并发执⾏%u轮次，每轮次concurrent dealloc %u次: 花费：%u ms\n",
        nworks, rounds, ntimes, (unsigned int)free_time);
    printf("%u个线程并发concurrent alloc&dealloc %u次，总计花费：%u ms\n",
        nworks, nworks * rounds * ntimes, (unsigned int)total_time);
}

int main()
{
    size_t n = 100;
    std::cout << "==========================================================" << std::endl;
    BenchmarkConcurrentMalloc(n, 4, 10);
    std::cout << std::endl << std::endl;
    BenchmarkMalloc(n, 4, 10);
    std::cout << "==========================================================" << std::endl;
    return 0;
}